{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from mikeio.dfs0 import Dfs0\n",
    "from mikeio.eum import TimeStep\n",
    "from datetime import datetime, timedelta"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create a timeseries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = []\n",
    "\n",
    "nt = 10\n",
    "d1 = np.zeros(nt)\n",
    "data.append(d1)\n",
    "d2 = np.ones(nt)\n",
    "data.append(d2)\n",
    "\n",
    "names = [\"Zeros\", \"Ones\"]\n",
    "\n",
    "dfs = Dfs0()\n",
    "\n",
    "\n",
    "dfs.create(filename=\"test.dfs0\", data=data, names=names, title=\"Zeros and ones\",\n",
    "           start_time=datetime(2000,1,1),\n",
    "           timeseries_unit=TimeStep.DAY, dt=7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Read a timeseries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "res = dfs.read(\"test.dfs0\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Zeros', 'Ones']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res.names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[datetime.datetime(2000, 1, 1, 0, 0),\n",
       " datetime.datetime(2000, 1, 8, 0, 0),\n",
       " datetime.datetime(2000, 1, 15, 0, 0),\n",
       " datetime.datetime(2000, 1, 22, 0, 0),\n",
       " datetime.datetime(2000, 1, 29, 0, 0),\n",
       " datetime.datetime(2000, 2, 5, 0, 0),\n",
       " datetime.datetime(2000, 2, 12, 0, 0),\n",
       " datetime.datetime(2000, 2, 19, 0, 0),\n",
       " datetime.datetime(2000, 2, 26, 0, 0),\n",
       " datetime.datetime(2000, 3, 4, 0, 0)]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res.time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]),\n",
       " array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res.data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Or as a Pandas dataframe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Zeros</th>\n",
       "      <th>Ones</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2000-01-01</th>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2000-01-08</th>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2000-01-15</th>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2000-01-22</th>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2000-01-29</th>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Zeros  Ones\n",
       "2000-01-01    0.0   1.0\n",
       "2000-01-08    0.0   1.0\n",
       "2000-01-15    0.0   1.0\n",
       "2000-01-22    0.0   1.0\n",
       "2000-01-29    0.0   1.0"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = dfs.read_to_pandas(\"test.dfs0\")\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create a timeseries with non-equidistant data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = []\n",
    "\n",
    "d1 = np.random.uniform(low=0.0, high=5.0, size=5)\n",
    "data.append(d1)\n",
    "\n",
    "datetimes = [\n",
    "    datetime(2000, 1, 1, 0, 0),\n",
    "    datetime(2000, 1, 8, 0, 0),\n",
    "    datetime(2000, 1, 10, 0, 0),\n",
    "    datetime(2000, 2, 22, 0, 0),\n",
    "    datetime(2000, 11, 29, 0, 0)\n",
    "]\n",
    "\n",
    "dfs = Dfs0()\n",
    "\n",
    "\n",
    "dfs.create(filename=\"neq.dfs0\",\n",
    "           datetimes=datetimes, \n",
    "           data=data,\n",
    "           title=\"Non equidistant\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create a timeseries with accumulated timestep"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Find correct eum units"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{100190: 'Correction of precipitation',\n",
       " 100192: 'Precipitation correction',\n",
       " 100232: 'Precipitation',\n",
       " 100233: 'Specific Precipitation',\n",
       " 100431: 'Precipitation Rate'}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from mikeio.dfs_util import type_list, unit_list\n",
    "\n",
    "\n",
    "type_list(\"Prec\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2004: 'mm/day',\n",
       " 2001: 'mm/hour',\n",
       " 2018: 'cm/hour',\n",
       " 2000: 'meter/sec',\n",
       " 2006: 'meter/day',\n",
       " 2009: 'feet/day',\n",
       " 2016: 'inch/hour',\n",
       " 2014: 'inch/min',\n",
       " 4802: 'inch/day',\n",
       " 2040: 'mm/year'}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unit_list(100431)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from DHI.Generic.MikeZero.DFS import DataValueType\n",
    "n= 1000\n",
    "d1 = np.random.random([n])\n",
    "d2 = np.random.random([n])\n",
    "data = []\n",
    "data.append(d1)\n",
    "data.append(d2)\n",
    "start_time = datetime(2017, 1, 1)\n",
    "time_vector = []\n",
    "t = start_time\n",
    "random_dt = np.random.choice([1.0,2.0],size=n)\n",
    "for i in range(n):\n",
    "    t = t + timedelta(hours=random_dt[i])\n",
    "    time_vector.append(t)\n",
    "title = 'Hello Test'\n",
    "names = ['Water level', 'Precipitation']\n",
    "variable_type = [100000, 100431]\n",
    "unit = [1000, 2004]\n",
    "data_value_type = [DataValueType.Instantaneous, DataValueType.Accumulated]\n",
    "\n",
    "dfs = Dfs0()\n",
    "dfs.create(filename='accumulated.dfs0', data=data,\n",
    "        datetimes=time_vector,\n",
    "        names=names, title=title,\n",
    "        variable_type=variable_type, unit=unit,\n",
    "        data_value_type=data_value_type)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modify an existing timeseries\n",
    "\n",
    "The `write` method allows to modify the data without the need of specifying names, units etc. If you need to add variables, rename, change units, you must use `create` instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DataSet(data, time, names)\n",
       "Number of items: 2\n",
       "Shape: (10,)\n",
       "2000-01-01 00:00:00 - 2000-03-04 00:00:00"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res = dfs.read(\"test.dfs0\")\n",
    "res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1.])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res['Ones']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modify the data in some way..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3.14159265, 3.14159265, 3.14159265, 3.14159265, 3.14159265,\n",
       "       3.14159265, 3.14159265, 3.14159265, 3.14159265, 3.14159265])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = res.data\n",
    "data[1] = data[1]*np.pi\n",
    "data[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "from shutil import copyfile\n",
    "copyfile(\"test.dfs0\",\"modified.dfs0\")\n",
    "dfs.write(\"modified.dfs0\", data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3.14159274, 3.14159274, 3.14159274, 3.14159274, 3.14159274,\n",
       "       3.14159274, 3.14159274, 3.14159274, 3.14159274, 3.14159274])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res = dfs.read(\"modified.dfs0\")\n",
    "res['Ones']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The second item is modified."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res['Zeros']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Convert units\n",
    "\n",
    "Read a file with waterlevel i meters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'m'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dfs = Dfs0()\n",
    "filename = r\"C:\\Program Files (x86)\\DHI\\2020\\MIKE Zero\\Examples\\MIKE_21\\FlowModel_FM\\HD\\Oresund\\Data\\1993\\Boundary_Conditions\\waterlevel_viken.dfs0\"\n",
    "\n",
    "ds = dfs.read(filename)\n",
    "dfs._dfs.ItemInfo[0].Quantity.UnitAbbreviation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\JAN\\AppData\\Local\\Continuum\\miniconda3\\lib\\site-packages\\pandas\\plotting\\_matplotlib\\converter.py:103: FutureWarning: Using an implicitly registered datetime converter for a matplotlib plotting method. The converter was registered by pandas on import. Future versions of pandas will require you to explicitly register matplotlib converters.\n",
      "\n",
      "To register the converters:\n",
      "\t>>> from pandas.plotting import register_matplotlib_converters\n",
      "\t>>> register_matplotlib_converters()\n",
      "  warnings.warn(msg, FutureWarning)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.plot(ds.time,ds.data[0])\n",
    "plt.ylabel(ds.names[0]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The aim is to convert this timeseries to feet (1m = 3.3 ft)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = ds.data\n",
    "data[0] = data[0]*3.3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{100000: 'Water Level', 100307: 'Water level change'}"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type_list(\"Water level\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1000: 'meter',\n",
       " 1001: 'kilometer',\n",
       " 1007: 'centimeter',\n",
       " 1002: 'millimeter',\n",
       " 1003: 'feet',\n",
       " 1014: 'feet US',\n",
       " 1004: 'inch',\n",
       " 1013: 'inch US',\n",
       " 1005: 'mile',\n",
       " 1016: 'mile US',\n",
       " 1006: 'yard',\n",
       " 1015: 'yard US'}"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unit_list(100000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "dfs = Dfs0()\n",
    "dfs.create(filename='wl_feet.dfs0', data=ds.data,\n",
    "           start_time=ds.time[0],\n",
    "            dt = 1800,\n",
    "            names=[\"Viken\"],\n",
    "            title=\"Water level\",\n",
    "            variable_type=[100000], unit=[1003])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![WL](../images/wl_feet.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Clean up"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "\n",
    "os.remove(\"test.dfs0\")\n",
    "os.remove(\"modified.dfs0\")\n",
    "os.remove(\"neq.dfs0\")\n",
    "os.remove(\"accumulated.dfs0\")\n",
    "os.remove(\"wl_feet.dfs0\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
